/**
 * 认证工具类
 * 提供登录状态检查、用户信息管理等功能
 * 
 * 重要：状态逻辑说明
 * ===================
 * 
 * 1. 授权状态 (isLoggedIn)
 *    - true: 小程序已完成静默授权（微信授权成功）
 *    - false: 未授权
 * 
 * 2. 会员状态 (userInfo.phone)
 *    - 有值: 用户是真实的小程序会员（已绑定手机号）
 *    - 无值: 已授权但非会员（需要绑定手机号成为会员）
 * 
 * 3. 完整状态组合
 *    - isLoggedIn: true + userInfo.phone有值 = 真实会员
 *    - isLoggedIn: true + userInfo.phone无值 = 已授权但非会员
 *    - isLoggedIn: false = 未授权
 * 
 * 4. 业务逻辑
 *    - 微信授权只是获取用户身份（静默授权）
 *    - 绑定手机号才是成为真正会员的标志
 *    - 只有会员才能享受完整的服务功能
 * 
 * 5. 页面处理建议
 *    - isLoggedIn: false → 提示用户需要授权
 *    - isLoggedIn: true + userInfo.phone无值 → 提示用户需要绑定手机号成为会员
 *    - isLoggedIn: true + userInfo.phone有值 → 用户是真实会员，可享受完整功能
 */

const request = require('../libs/request.js')

/**
 * 检查用户是否已登录
 * @returns {Promise<Object>} 返回登录状态对象
 */
const checkLoginStatus = async () => {
  try {
    // 获取本地存储的token和用户信息
    const token = request.getToken()
    const userInfo = wx.getStorageSync('userInfo')
    
    if (!token) {
      return {
        isLoggedIn: false,
        status: 'not_logged_in',
        message: '本地无登录信息'
      }
    }
    
    // 验证用户信息完整性
    if (!isValidUserInfo(userInfo)) {
      return {
        isLoggedIn: true,
        status: 'invalid_user_info',
        message: '用户信息不完整',
        userInfo: userInfo
      }
    }
    
    // 直接使用本地数据，不向服务器验证
    return {
      isLoggedIn: true,
      status: 'logged_in',
      message: '用户已登录',
      userInfo: userInfo
    }
    
  } catch (error) {
    console.error('检查登录状态失败:', error)
    return {
      isLoggedIn: false,
      status: 'error',
      message: '检查登录状态失败'
    }
  }
}

/**
 * 验证用户信息完整性
 * @param {Object} userInfo 用户信息
 * @returns {boolean}
 */
const isValidUserInfo = (userInfo) => {
  if (!userInfo || typeof userInfo !== 'object') {
    return false
  }
  
  // 检查用户信息存在且手机号有值
  return userInfo.phone && userInfo.phone.trim() !== ''
}

/**
 * 获取本地存储的用户信息
 * @returns {Object|null}
 */
const getUserInfo = () => {
  return wx.getStorageSync('userInfo') || null
}

/**
 * 获取本地存储的token
 * @returns {string|null}
 */
const getToken = () => {
  return wx.getStorageSync('token') || null
}

/**
 * 保存用户信息到本地存储
 * @param {Object} userInfo
 */
const setUserInfo = (userInfo) => {
  if (isValidUserInfo(userInfo)) {
    wx.setStorageSync('userInfo', userInfo)
  }
}

/**
 * 清除本地用户数据
 */
const clearLocalUserData = () => {
  request.clearToken()
  wx.removeStorageSync('userInfo')
  console.log('本地用户数据已清除')
}

/**
 * 启动方法（微信授权）
 * @returns {Promise<Object>}
 */
const login = async () => {
  try {
    // 先获取微信登录code
    const loginRes = await new Promise((resolve, reject) => {
      wx.login({
        success: (res) => {
          if (res.code) {
            resolve(res);
          } else {
            reject(new Error('微信启动失败'));
          }
        },
        fail: (err) => {
          reject(err);
        }
      });
    });
    
    // 发送启动请求，传递code
    const response = await request.post('/v1/user/init', {
      code: loginRes.code
    })
    
    if (response.code === 1 && response.data) {
      const { token, user } = response.data
      
      // 验证返回数据的完整性
      if (!token || !user) {
        throw new Error('服务器返回数据不完整')
      }
      
      // 保存到本地存储
      request.setToken(token)
      setUserInfo(user)
      
      return {
        success: true,
        token: token,
        userInfo: user,
        message: '启动成功'
      }
    } else {
      throw new Error(response.message || '启动失败')
    }
    
  } catch (error) {
    console.error('启动失败:', error)
    return {
      success: false,
      message: error.message || '启动失败'
    }
  }
}

/**
 * 绑定手机号
 * @param {Object} phoneData 手机号数据 {code, encryptedData, iv}
 * @returns {Promise<Object>}
 */
const bindPhone = async (phoneData) => {
  try {
    const { code, encryptedData, iv } = phoneData
    
    if (!code || !encryptedData || !iv) {
      throw new Error('手机号数据不完整')
    }
    
    // 调用绑定手机号接口
    const response = await request.authPost('/v1/user/bindPhone', {
      code: code,
      encryptedData: encryptedData,
      iv: iv
    })
    
    if (response.code === 1 && response.data) {
      // 更新本地用户信息
      const updatedUserInfo = response.data.user
      setUserInfo(updatedUserInfo)
      
      return {
        success: true,
        userInfo: updatedUserInfo,
        phone: response.data.phone,
        message: response.message || '手机号绑定成功'
      }
    } else {
      throw new Error(response.message || '绑定失败')
    }
    
  } catch (error) {
    console.error('绑定手机号失败:', error)
    return {
      success: false,
      message: error.message || '绑定手机号失败'
    }
  }
}

/**
 * 修改手机号
 * @param {Object} phoneData 手机号数据 {code, encryptedData, iv}
 * @returns {Promise<Object>}
 */
const changePhone = async (phoneData) => {
  try {
    const { code, encryptedData, iv } = phoneData
    
    if (!code || !encryptedData || !iv) {
      throw new Error('手机号数据不完整')
    }
    
    // 调用修改手机号接口
    const response = await request.authPost('/v1/user/changePhone', {
      code: code,
      encryptedData: encryptedData,
      iv: iv
    })
    
    if (response.code === 1 && response.data) {
      // 更新本地用户信息
      const updatedUserInfo = response.data.user
      setUserInfo(updatedUserInfo)
      
      return {
        success: true,
        userInfo: updatedUserInfo,
        phone: response.data.phone,
        message: response.message || '手机号修改成功'
      }
    } else {
      throw new Error(response.message || '修改失败')
    }
    
  } catch (error) {
    console.error('修改手机号失败:', error)
    return {
      success: false,
      message: error.message || '修改手机号失败'
    }
  }
}

/**
 * 退出登录
 * @returns {Promise<Object>}
 */
const logout = async () => {
  try {
    // 调用退出登录接口
    await request.authPost('/v1/user/logout')
    
    // 清除本地数据
    clearLocalUserData()
    
    return {
      success: true,
      message: '退出登录成功'
    }
    
  } catch (error) {
    console.error('退出登录失败:', error)
    // 即使服务器请求失败，也清除本地数据
    clearLocalUserData()
    
    return {
      success: true,
      message: '本地数据已清除'
    }
  }
}

/**
 * 刷新用户信息
 * @returns {Promise<Object>}
 */
const refreshUserInfo = async () => {
  try {
    const response = await request.authGet('/v1/user/profile')
    
    if (response.code === 1 && response.data) {
      // 验证用户信息完整性
      if (!isValidUserInfo(response.data)) {
        throw new Error('服务器返回的用户信息不完整')
      }
      
      // 更新本地用户信息
      setUserInfo(response.data)
      
      return {
        success: true,
        userInfo: response.data,
        message: '用户信息已更新'
      }
    } else {
      throw new Error(response.message || '获取用户信息失败')
    }
    
  } catch (error) {
    console.error('刷新用户信息失败:', error)
    return {
      success: false,
      message: error.message || '获取用户信息失败'
    }
  }
}

/**
 * 检查是否需要重新登录
 * @returns {Promise<boolean>}
 */
const needReLogin = async () => {
  const loginStatus = await checkLoginStatus()
  return !loginStatus.isLoggedIn
}

module.exports = {
  checkLoginStatus,
  getUserInfo,
  setUserInfo,
  clearLocalUserData,
  logout,
  refreshUserInfo,
  login,
  bindPhone,
  isValidUserInfo,
  needReLogin,
  getToken,
  changePhone
} 